home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / DSHJ2 / SETUP.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-10  |  12.6 KB  |  585 lines
  1. #include    <gemdefs.h>
  2. #include    <obdefs.h>
  3. #include    <osbind.h>
  4. #include    "deskset2.h"
  5. #include    "comp.h"
  6.  
  7. extern    unsigned    hlq[UNIT4], vlq[UNIT4];
  8. extern    double        hrq[UNIT4], vrq[UNIT4], modf();
  9. extern    struct txtattr    gltxtattr;        /* global text attrib    */
  10. extern    char        syspath[];        /* boot up  path...    */
  11. extern    char        widpath[];        /* WID file path...    */
  12. extern    char        *dpath1;        /* TXT file path...    */
  13. extern    char        *get_edit();
  14. extern     unsigned long     gl_region_ptr;        /* selected text region    */
  15. extern    unsigned    formval;
  16. extern    int        unit_type, pagetype;    /* Atari setup Vars    */
  17. extern  int         attr_flag[];        /* cjg             */
  18.  
  19. static    char    drsex[] = "*.DRS";        /* gdosfname mode 0    */
  20. static    char    exdex[] = "*.DIC";        /* gdosfname mode 1    */
  21. static    char    lytex[] = "*.LYT";        /* gdosfname mode 2    */
  22. static    char    widex[] = "*.WID";        /* gdosfname mode 3    */
  23. static    char    txtex[]    = "*.TXT";        /* gdosfname mode 4    */
  24. static    int    deskx, desky, deskw, deskh;
  25.  
  26. char        fs_iinsel[14];        /* filename from gdosfname()    */
  27. int        Pval;            /* parmcheck() result value    */
  28.  
  29. updATTr()                /* ATARI */
  30. {
  31.      upd_txt_attributes();        /* update one or many regions */
  32.                     /* function found in resource */
  33. }
  34.  
  35.  
  36. do_hylang()
  37. {
  38.     OBJECT    *hyobj;
  39.     int    button;
  40.     char    svhylg;
  41.  
  42.     rsrc_gaddr(0,HYLAN,&hyobj);
  43.     set_nor(hyobj,ENG,DAN);
  44.     hyobj[setp.hylg].ob_state = SELECTED;
  45.     svhylg = setp.hylg;
  46.  
  47.     button = execform(hyobj,0);
  48.     hyobj[button].ob_state = NORMAL;
  49.     if (button == HYLOK && whichSEL(hyobj,&setp.hylg,ENG,DAN)) {
  50.         ++setp.hylg;
  51.         if (!ld_lang()) {        /* load Hyp. language    */
  52.             setp.hylg = svhylg;    /* if error reload old    */
  53.             ld_lang();
  54.         }
  55.     }
  56. }
  57.  
  58. do_hypar()
  59. {
  60.     OBJECT    *hyparobj;
  61.     int    button;
  62.     int    i, j, k;
  63.     
  64.     clr_attr_flag();    /* cjg */
  65.  
  66.     rsrc_gaddr(0,HYPARS,&hyparobj);
  67.     set_int(hyparobj,SUHY ,gltxtattr.nsuchyp);
  68.     set_int(hyparobj,CHBHY,gltxtattr.nbefhyp);
  69.     set_int(hyparobj,CHAHY,gltxtattr.nafthyp);
  70.     set_nor(hyparobj,HMOFF,HMON);
  71.     hyparobj[gltxtattr.hypmd ? HMON:HMOFF].ob_state = SELECTED;
  72.  
  73.     formval = SUHY;
  74.     dial1(hyparobj);
  75. err:    button = dial2(hyparobj);
  76.     if (button == HYOK) {
  77.         i = get_int(hyparobj,SUHY);
  78.         j = get_int(hyparobj,CHBHY);
  79.         k = get_int(hyparobj,CHAHY);
  80.         if (!ck_hyerr(i,j,k,SUHY,CHBHY,CHAHY)) {
  81.             gltxtattr.hypmd = (hyparobj[HMON].ob_state & SELECTED);
  82.             gltxtattr.nsuchyp = i;
  83.             gltxtattr.nbefhyp = j;
  84.             gltxtattr.nafthyp = k;
  85.            attr_flag[9]=attr_flag[10]=attr_flag[11]=attr_flag[12]=1; /* CJG*/
  86.         }
  87.         else    goto err;
  88.         updATTr();        /* ATARI */
  89.     }
  90.     dial3();
  91. }
  92.  
  93. do_pwrup()
  94. {
  95.     OBJECT    *pwobj;
  96.     int    button;
  97.     char    drsbuf[16], dicbuf[16], lytbuf[16];
  98.     char    buf1[100], buf2[100], buf3[100];
  99.         
  100.     rsrc_gaddr(0,PWFILES,&pwobj);
  101.     set_str(pwobj,DRESS,setp.ftdrs,drsbuf);
  102.     set_str(pwobj,DICT,setp.edict,dicbuf);
  103.     set_str(pwobj,LAYOUT,setp.kblyt,lytbuf);
  104.  
  105.     do {
  106.       button = execform(pwobj,0);
  107.       pwobj[button].ob_state = NORMAL;
  108.       BWredraw();                    /* redraw TW/PW    */
  109.       switch (button) {
  110.       case DRESS:
  111.         if (gdosfname(buf1,0,0))
  112.             strcpy(drsbuf,fs_iinsel);
  113.         break;
  114.       case DICT:
  115.         if (gdosfname(buf2,1,1))
  116.             strcpy(dicbuf,fs_iinsel);
  117.         break;
  118.       case LAYOUT:
  119.         if (gdosfname(buf3,2,1))
  120.             strcpy(lytbuf,fs_iinsel);
  121.         break;
  122.       case PWOK:
  123.         if (strcmp(setp.ftdrs,drsbuf)) {
  124.           if (Fnt_cmd('L',buf1))    /* load Font dress..    */
  125.             strcpy(setp.ftdrs,drsbuf);
  126.         }
  127.         if (strcmp(setp.edict,dicbuf)) {
  128.           if (ld_dict(buf2,1))        /* load Dictionary..    */
  129.             strcpy(setp.edict,dicbuf);
  130.         }
  131.         if (strcmp(setp.kblyt,lytbuf)) {
  132.           if (ld_lyt(lytbuf) == 2)    /* load Keyboard Layout    */
  133.             strcpy(setp.kblyt,lytbuf);
  134.         }
  135.         break;
  136.       }
  137.     } while (button != PWOK && button != PWCAN);
  138. }
  139.  
  140. do_chcomp()
  141. {
  142.     OBJECT    *compobj;
  143.     int    button;
  144.     char    *mcc, sel;
  145.  
  146.         clr_attr_flag();
  147.  
  148.     rsrc_gaddr(0,CHARCOMP,&compobj);
  149.     set_nor(compobj,ACCSET1,ACCSET3);
  150.     set_nor(compobj,ACCOFF,ACCON);
  151.     set_nor(compobj,MCCOFF,MCCON);
  152.     set_int(compobj,MCCSETVL,gltxtattr.mcomp / 2);
  153.     compobj[gltxtattr.mcomp ? MCCON:MCCOFF].ob_state = SELECTED;
  154.     compobj[gltxtattr.acomp ? ACCON:ACCOFF].ob_state = SELECTED;
  155.     if (gltxtattr.acomp)
  156.         compobj[gltxtattr.acomp == 1 ? ACCSET1:
  157.             gltxtattr.acomp == 2 ? ACCSET2:
  158.             ACCSET3].ob_state = SELECTED;
  159.  
  160.     formval = MCCSETVL;
  161.     dial1(compobj);
  162.     button = dial2(compobj);
  163.     if (button == COMPOK) {
  164.         if (compobj[ACCON].ob_state == SELECTED &&
  165.             whichSEL(compobj,&sel,ACCSET1,ACCSET3)) {
  166.             gltxtattr.acomp = ++sel;
  167.         }
  168.         else    gltxtattr.acomp = 0;
  169.         attr_flag[7] = 1;
  170.  
  171.         if (compobj[MCCON].ob_state == SELECTED) {
  172.             mcc = get_edit(compobj,MCCSETVL);
  173.             gltxtattr.mcomp = atoi(mcc) * 2;
  174.         }
  175.         else    gltxtattr.mcomp = 0;
  176.         attr_flag[6] = 1;
  177.         updATTr();        /* ATARI */
  178.     }
  179.     dial3();
  180. }
  181.  
  182.  
  183. do_wdsp()
  184. {
  185.     OBJECT    *wdspobj;
  186.     int    button, i, j, k;
  187.  
  188.     clr_attr_flag();
  189.  
  190.     rsrc_gaddr(0,WORDSPC,&wdspobj);
  191.     set_nor(wdspobj,LSPOFF,LSPON);
  192.     set_int(wdspobj,CPPOS,gltxtattr.plts);
  193.     set_int(wdspobj,CPNEG,gltxtattr.nlts);
  194.     set_int(wdspobj,CPMIN,gltxtattr.minsp);
  195.     set_int(wdspobj,CPPRF,gltxtattr.prfsp);
  196.     set_int(wdspobj,CPMAX,gltxtattr.maxsp);
  197.     wdspobj[gltxtattr.ltsmd ? LSPON:LSPOFF].ob_state = SELECTED;
  198.  
  199.     formval = CPMIN;
  200.     dial1(wdspobj);
  201. err:    button = dial2(wdspobj);
  202.     if (button == CPOK) {
  203.         gltxtattr.plts = get_int(wdspobj,CPPOS);
  204.         if ((i = get_int(wdspobj,CPNEG)) > 6) {
  205.             formval = CPNEG;
  206.             do_alert(BADINP);
  207.             goto err;
  208.         }
  209.         else    gltxtattr.nlts = i;
  210.         i = get_int(wdspobj,CPMIN);
  211.         j = get_int(wdspobj,CPPRF);
  212.         k = get_int(wdspobj,CPMAX);
  213.         if (!ck_sperr(i,j,k,CPMIN,CPPRF,CPMAX)) {
  214.             gltxtattr.minsp = i;
  215.             gltxtattr.prfsp = j;
  216.             gltxtattr.maxsp = k;
  217.             attr_flag[16] = attr_flag[17] = attr_flag[18] = 1;
  218.         }
  219.         else    goto err;
  220.         gltxtattr.ltsmd = (wdspobj[LSPON].ob_state & SELECTED);
  221.         attr_flag[13] = 1;
  222.         updATTr();        /* ATARI */
  223.     }
  224.     dial3();
  225. }
  226.  
  227. do_just()
  228. {
  229.     OBJECT    *justobj;
  230.     int    button;
  231.     char    sel;
  232.  
  233.     clr_attr_flag();
  234.  
  235.     rsrc_gaddr(0,JUSTIFI,&justobj);
  236.     set_nor(justobj,AUTOJUST,AUTOCTR);
  237.     justobj[gltxtattr.jstmd+AUTOJUST].ob_state = SELECTED;
  238.  
  239.     button = execform(justobj,0);
  240.     justobj[button].ob_state = NORMAL;
  241.     if (button == JUSTOK && whichSEL(justobj,&sel,AUTOJUST,AUTOCTR))
  242.     {
  243.         gltxtattr.jstmd = sel;
  244.         attr_flag[21] = 1;
  245.         updATTr();        /* ATARI */
  246.     }
  247. }
  248.  
  249. ck_hyerr(i,j,k,v1,v2,v3)
  250. int    i, j, k, v1, v2, v3;
  251. {
  252.     if (!i) {
  253.           formval = v1;
  254. err:        do_alert(BADINP);
  255.         return(1);
  256.     }
  257.     else
  258.     if (j < 2) {
  259.           formval = v2;
  260.         goto err;
  261.     }
  262.     else
  263.     if (k < 2) {
  264.           formval = v3;
  265.         goto err;
  266.     }
  267.     return(0);
  268. }
  269.  
  270. ck_sperr(i,j,k,v1,v2,v3)
  271. int    i, j, k, v1, v2, v3;
  272. {
  273.     if ((i + j) > 99) {
  274.         formval = v1;
  275. err:        do_alert(BADINP);
  276.         return(1);
  277.     }
  278.     else
  279.     if ((i + k) > 99) {
  280.         formval = v2;
  281.         goto err;
  282.     }
  283.     else
  284.     if (j > k) {
  285.         formval = v3;
  286.         goto err;
  287.     }
  288.     return(0);
  289. }
  290.  
  291. /*
  292.     Routine to copy a source digit string "s" to a target one "t"
  293.     while counting the number of digit.
  294.     Return updated source pointer.
  295. */
  296. static    char    *gNstr(s,t,ndig)
  297. char    *s, *t, *ndig;
  298. {
  299.     *ndig = 0;
  300.     while (cdigit(*s))
  301.     { *t++ = *s++; ++(*ndig); }
  302.     *t = 0;
  303.     return(s);
  304. }
  305.  
  306. /*
  307.     Input string conversion and Value check
  308.     cmd    1 - X value
  309.         2 - Point/Set size
  310.         3 - Y value
  311.         4 - LineSpace
  312.     nflag = 0 - don't allow negative numbers.
  313.         1 - Allow negative numbers.
  314. */
  315. checkValue(input,cmd,nflag)
  316. char    *input;
  317. int    cmd;
  318. int    nflag;
  319. {
  320.     char        bfdot[8], afdot[8], ldig, rdig;
  321.     unsigned    lnum, rnum, maxx, maxy, maxls;
  322.     int        erf = 0;
  323.     double        dval, intg;
  324.     int flag;
  325.  
  326.     flag = 0;
  327.     if (*input) {
  328.         if((*input == '-')&& nflag)
  329.         {
  330.              input++;
  331.              flag = 1;
  332.         }
  333.  
  334.         input = gNstr(input,bfdot,&ldig);
  335.         if (ldig > 4)
  336.             goto err;
  337.     }
  338.     else    goto err;
  339.     if (*input == '.') {
  340.         input = gNstr(++input,afdot,&rdig);
  341.         if (rdig > 2)
  342.             goto err;
  343.     }
  344.     else    afdot[0] = rdig = 0;
  345.     if (*input)
  346.         goto err;
  347.     lnum = atoi(bfdot);
  348.     rnum = atoi(afdot);
  349.     if (cmd != 2 && !unit_type && rdig == 1)
  350.         rnum *= 10;
  351.     getmax(&maxx,&maxy,&maxls);
  352.     switch (cmd) {
  353.     case 1:                    /* all line measures    */
  354.         if (rnum >= hlq[unit_type])
  355.             goto err;
  356.         dval =    (double)lnum *        /* convert XXX. first    */
  357.             (double)hlq[unit_type] * hrq[unit_type];
  358.         if (rnum > 0)            /* convert .XX to add    */
  359.             dval += ((double)rnum * hrq[unit_type]);
  360.         dval = modf(dval,&intg);    /* get mod. to adjust    */
  361.         lnum = (unsigned)intg;        /* get integral part    */
  362.         if (dval >= 0.5)
  363.             ++lnum;
  364.         if (lnum > maxx)        /* validate new value    */
  365. err:            erf = 1;
  366.         else    Pval = lnum;
  367.         break;
  368.     case 2:                    /* all point sizes    */
  369.         if (!lnum            /* no zero on XXX.    */
  370.             ||
  371.            (rnum != 0 && rnum != 5)    /* .X is only 0 or 5    */
  372.             ||
  373.            (setp.omod == 2 &&        /* special for CG 8200:    */
  374.             lnum >= 36 && rnum))    /* 36-72 pt in 1pt inc    */
  375.             goto err;
  376.         lnum = pt12(lnum,rnum);        /* compute 8th pt value    */
  377.         if (ptszck(lnum))        /* validate new value    */
  378.             goto err;
  379.         else    Pval = lnum;
  380.         break;
  381.     case 3:                    /* all depth measures    */
  382.     case 4:                    /* all LineSpaces    */
  383.         if (rnum >= vlq[unit_type])    /* .XX within range    */
  384.             goto err;
  385.         dval =    (double)lnum *        /* convert XXX. first    */
  386.             (double)vlq[unit_type] * vrq[unit_type];
  387.         if (rnum > 0)            /* convert .XX to add    */
  388.             dval += ((double)rnum * vrq[unit_type]);
  389.         dval = modf(dval,&intg);    /* get mod. to adjust    */
  390.         lnum = (unsigned)intg;        /* get integral part    */
  391.         if (dval >= 0.5)
  392.             ++lnum;
  393.         if (cmd == 3) {
  394.           if (lnum > maxy)        /* validate new depth    */
  395.             goto err;
  396.         }
  397.         else {
  398.           if (lnum > maxls)        /* validate LineSpace    */
  399.             goto err;
  400.         }
  401.         Pval = lnum;
  402.         break;
  403.     }
  404.     if(flag && nflag)
  405.        Pval = -Pval;
  406.     return(erf);
  407. }
  408.  
  409. parmcheck(dialog,obj,mode,nflag)
  410. OBJECT    *dialog;
  411. int    obj, mode;
  412. int     nflag;
  413. {
  414.     char    **str;
  415.  
  416.     formval = obj;
  417.     str    = (char **)dialog[obj].ob_spec;
  418.     if (checkValue(*str,mode,nflag)) {
  419.         do_alert(BADINP);
  420.         return(1);
  421.     }
  422.     else    return(0);
  423. }
  424.  
  425. /*
  426.     Range check for point and set size
  427.     Value can be in 1/2 point increment and is stored in 1/8 point.
  428.     CG 8000, 8400, ep308 :    4 to 72 point
  429.     CG 8600 :        4 to 127.5 point
  430.     CG 8200 :        5 to 72 point    (from 36 to 72 only in
  431.                         1 point increment)
  432.     Atari Laser :        5 to 144 point
  433. */
  434. ptszck(sz)
  435. int    sz;
  436. {
  437.     if (setp.omod == 0)                /* TY 8600..    */
  438.         return(sz < 32 || sz > 1020);
  439.     else
  440.     if (setp.omod == 2)                /* TY 8200..    */
  441.         return(sz < 40 || sz > 576);
  442.     else
  443.     if (setp.omod == 5)                /* Laser...    */
  444.         return(sz < 40 || sz > 1152);
  445.     else    return(sz < 32 || sz > 576);    /* TY 8000, 8400, EP308 */
  446. }
  447.  
  448. whichSEL(obj,item,st,ct)
  449. OBJECT    *obj;
  450. char    *item;
  451. int    st, ct;
  452. {
  453.     int    i;
  454.  
  455.     for (i = st;i <= ct && !(obj[i].ob_state & SELECTED);++i);
  456.     if (i <= ct) {
  457.         *item = i - st;
  458.         return(1);
  459.     }
  460.     else    return(0);
  461. }
  462.  
  463. set_nor(obj,st,ct)
  464. OBJECT    *obj;
  465. int    st, ct;
  466. {
  467.     int    i;
  468.  
  469.     for (i = st;i <= ct;++i)
  470.         obj[i].ob_state = NORMAL;
  471. }
  472.  
  473. do_alert(msgno)
  474. int    msgno;
  475. {
  476.     char    *ptr;
  477.  
  478.     rsrc_gaddr(R_STRING,msgno,&ptr);
  479.     return(form_alert(1,ptr));
  480. }
  481.  
  482. set_str(tree,index,source,target)
  483. OBJECT    *tree;
  484. int    index;
  485. char    *source;
  486. char    *target;
  487. {
  488.     strcpy(target,source);
  489.     tree[index].ob_spec = (long)target;
  490. }
  491.  
  492. /********************************/
  493. /*    Use file selector    */
  494. /*    to get input file    */
  495. /********************************/
  496. gdosfname(filename,spec,check)
  497. char    *filename;
  498. int    spec, check;
  499. {
  500.     int    fs_iexbutton, ret;
  501.     char    *path, *fspec;
  502.  
  503. /*    Note:    filename large enough to hold
  504.         system path and user selection !    */
  505.     switch(spec) {
  506.     case 0:    path    = syspath;
  507.         fspec    = drsex;
  508.         break;
  509.     case 1:    path    = syspath;
  510.         fspec    = exdex;
  511.         break;
  512.     case 2:    path    = syspath;
  513.         fspec    = lytex;
  514.         break;
  515.     case 3:    path    = widpath;
  516.         fspec    = widex;
  517.         break;
  518.     case 4:    path    = dpath1;
  519.         fspec    = txtex;
  520.         break;
  521.     }
  522.     strcpy(filename,path);
  523.     strcat(filename,fspec);
  524.     fs_iinsel[0] = 0;
  525.     if (fsel_input(filename,fs_iinsel,&fs_iexbutton) &&
  526.         fs_iexbutton && fs_iinsel[0]) {
  527.         strunc(fs_iinsel);
  528.         strcat(fs_iinsel,fspec+1);
  529.         filetopath(filename);
  530.         strcat(filename,fs_iinsel);
  531.         if (check) {
  532.             if (!(ret = (!access(filename,0)))) {
  533.                 BWredraw();        /* redraw TW/PW    */
  534.                 setnfd(fs_iinsel,1);
  535.             }
  536.         }
  537.         else    ret = 1;
  538.     }
  539.     else    ret = 0;
  540.     BWredraw();                    /* redraw TW/PW    */
  541.     return(ret);
  542. }
  543.  
  544. dial1(dialog)
  545. OBJECT    *dialog;
  546. {
  547.     form_center(dialog,&deskx,&desky,&deskw,&deskh);
  548.     form_dial(0,0,0,0,0,deskx,desky,deskw,deskh);
  549.     form_dial(1,0,0,0,0,deskx,desky,deskw,deskh);
  550. }
  551.  
  552. dial2(dialog)
  553. OBJECT    *dialog;
  554. {
  555.     int    exit_obj;
  556.  
  557.     objc_draw(dialog,0,10,deskx,desky,deskw,deskh);
  558.     exit_obj = form_do(dialog,formval);
  559.     dialog[exit_obj].ob_state = NORMAL;
  560.     return(exit_obj);
  561. }
  562.  
  563. dial3()
  564. {
  565.     form_dial(2,0,0,0,0,deskx,desky,deskw,deskh);
  566.     form_dial(3,0,0,0,0,deskx,desky,deskw,deskh);
  567. }
  568.  
  569. filetopath(filename)
  570. char    *filename;
  571. {
  572.     int    i;
  573.     char    c;
  574.  
  575.     i = strlen(filename);
  576.     while (i && ((c = filename[i-1]) != '\\' && c != ':'))
  577.         --i;
  578.     filename[i] = 0;
  579. }
  580.  
  581. get_pgtype()
  582. {
  583.     return(pagetype - PA4);
  584. }
  585.